home *** CD-ROM | disk | FTP | other *** search
/ Aminet 26 / Aminet 26 (1998)(GTI - Schatztruhe)[!][Aug 1998].iso / XiPaint / Developer / Modules / filter.c < prev    next >
C/C++ Source or Header  |  1995-09-09  |  35KB  |  1,087 lines
  1. /* Last Change: Thomas /   3. August 1995  07:27:56 */
  2.  
  3. //+ "/****  System-Includes  ****/"
  4.  
  5. /****  System-Includes  ****/
  6.  
  7. #include <stdlib.h>
  8. #include <stdio.h>
  9. #include <string.h>
  10.  
  11. #include <exec/exec.h>
  12. #include <exec/types.h>
  13. #include <exec/memory.h>
  14. #include <exec/execbase.h>
  15. #include <exec/ports.h>
  16.  
  17. #include <clib/alib_protos.h>
  18.  
  19. #include <dos/dosextens.h>
  20. #include <dos/dostags.h>
  21.  
  22. #include <proto/exec.h>
  23. #include <proto/dos.h>
  24. #include <include:libraries/iffparse.h>
  25.  
  26. #include "XiUser.h"
  27. //-
  28. //+ "struct brush{"
  29.  
  30. struct brush{
  31.   union color *memory;  /* brush-speicher */
  32.   WORD x,y;             /* merker für letzte transaktion. für blit! */
  33.   WORD width,height;
  34.   WORD alpha;           /* yes=1, no = 0 */
  35.   WORD nr;              /* welcher brush in der liste ist es denn? */
  36.   WORD hd_ram;          /* ist der brush im ram(0) oder auf der hd(1)? */
  37.   WORD mode;            /* 0 = rechteckiger brush, 1 polygon */
  38.   WORD offx, offy;      /* offset des cursors von der linken oberen ecke des brushes */
  39.   WORD art;             /* 0 = pinsel, 1=stift */
  40.   WORD belegt;          /* 0= frei, 255 ist besetzt */
  41. };
  42. //-
  43. //+ "union color{"
  44.  
  45. union color{
  46.         LONG c24;
  47.         UBYTE c8[4];
  48.         };
  49. //-
  50. #define RED 0
  51. #define GRN 1
  52. #define BLU 2
  53. #define KEY 3
  54.  
  55. #define REQ_PIC_W 60
  56. #define REQ_PIC_H 60
  57.  
  58.  
  59. //+ "Prototypes"
  60. int main(int argc, char **argv);
  61. void WaitReply(struct MsgPort *ReplyPort, struct Message *WaitMsg);
  62. BOOL open_xi_project(UWORD *w, UWORD *h, ULONG **mem, char *name);
  63. void update_project(void);
  64. BOOL unlock_project(void);
  65. BOOL lock_project(UWORD *w, UWORD *h, ULONG **mem);
  66. void send_mpic(WORD w, WORD h, union color *mem, char *id);
  67.  
  68. void send_error(char *string);
  69. void set_gauge(void *box, WORD prozent);
  70. void *open_gauge(char *title);
  71. BOOL make_minipic (ULONG *src, WORD swidth, WORD sheight,
  72.                    ULONG *dest, WORD dwidth, WORD dheight);
  73.  
  74. void filter_picture_smo(WORD w,WORD h,union color *mem);
  75. void filter_picture_sme(WORD w,WORD h,union color *mem);
  76.  
  77. void smooth_point (struct brush *omega, SHORT x, SHORT y);
  78. void smear_point (struct brush *omega, SHORT x, SHORT y);
  79.  
  80. //-
  81. //+ "Statical structs for dedecting"
  82. struct xi_ext_header info =
  83. {
  84.   "XIPAINT-EXTERNAL000",
  85.   3,2,
  86.   'F',
  87.   "Smoothing",
  88.   "Thomas Dorn",
  89.   1,0,
  90.   1,0,0,0,0,0,
  91.   0,0,0,
  92. };
  93. struct xi_ext_header info1 =
  94. {
  95.   "XIPAINT-EXTERNAL000",
  96.   3,2,
  97.   'F',
  98.   "Smear",
  99.   "Thomas Dorn",
  100.   1,0,
  101.   1,0,0,0,0,0,
  102.   0,0,0,
  103. };
  104.  
  105. //-
  106. //+ "Globals"
  107. struct XiMessage XiMsg;     // Sorry - my Global ones ...
  108. char ProjName[80];
  109. struct io_pic io;
  110. struct MsgPort *XiUserPort, *XiReplyPort;
  111.   void *box;
  112. char str_id[20];
  113. //-
  114.  
  115. int main(int argc, char **argv)
  116. {
  117.   UWORD w,h;             // Desired Format
  118.   ULONG *mem=NULL;           // To handle temporary
  119.   short i=1;
  120.   union color *bru;
  121.  
  122.   memset(&io,0,sizeof(struct io_pic));
  123.   io.todo = 'P';    // New Project is default
  124.   strcpy(io.port,"xiuser.port");
  125.  
  126.   // Auswerten der Kommandozeile (natuerlich nicht sooo)
  127.   //+ "  strcpy(io.name,argv[1]);"
  128.  
  129.   strcpy(io.name,argv[1]);
  130.   while (i < argc)
  131.   {
  132.     if (stricmp(argv[i],"filter") == 0)
  133.     {
  134.       io.ext.what = 'F';
  135.       i++;
  136.     }
  137.  
  138.     else if (stricmp(argv[i],"minipic") == 0)
  139.     {
  140.       io.minipic = 1;
  141.       i++;
  142.     }
  143.  
  144.     else if (stricmp(argv[i],"port") == 0)
  145.     {
  146.       i++;
  147.       if (i < argc)
  148.       {
  149.         strcpy(io.port,argv[i]);
  150.         i++;
  151.       }
  152.       else
  153.       {
  154.         printf("Error No Parameter given\n");
  155.       }
  156.     }
  157.     else if (stricmp(argv[i],"module") == 0)
  158.     {
  159.       i++;
  160.       if (i < argc)
  161.       {
  162.         strcpy(io.ext.format,argv[i]);
  163.         i++;
  164.       }
  165.       else
  166.       {
  167.         printf("Error No Parameter given\n");
  168.       }
  169.     }
  170.     else if (stricmp(argv[i],"project") == 0)
  171.     {
  172.       i++;
  173.       if (i < argc)
  174.       {
  175.         strcpy(io.proname,argv[i]);
  176.         io.todo = 'L';
  177.         i++;
  178.       }
  179.       else
  180.       {
  181.         printf("Error No id Parameter given\n");
  182.       }
  183.     }
  184.     else if (stricmp(argv[i],"id") == 0)
  185.     {
  186.       i++;
  187.       if (i < argc)
  188.       {
  189.         strcpy(str_id,argv[i]);
  190.         i++;
  191.       }
  192.       else
  193.       {
  194.         printf("Error No Parameter given\n");
  195.       }
  196.     }
  197.     else
  198.     {
  199.       printf("Unknown command\n");
  200.       i++;
  201.     }
  202.   }
  203. //-
  204.  
  205. //+ "Initialisation"
  206.      /**  Find the User-Port  **/
  207.     if ( (XiUserPort = FindPort((UBYTE *)(io.port))) == NULL )
  208.     {
  209.       printf("Couldn't find User-Port, is XiPaint started?\n");
  210.       exit(40);
  211.     }
  212.  
  213.     // Reply-Port
  214.     if ( (XiReplyPort = CreatePort(NULL, 0)) == NULL )
  215.     {
  216.       printf("Couldn't create a Reply-Port!\n");
  217.       exit(40);
  218.     }
  219.  
  220.     //  Initialise the Message
  221.     memset(&XiMsg, 0, sizeof(struct XiMessage));
  222.     XiMsg.ExecMess.mn_Node.ln_Type = NT_MESSAGE;
  223.     XiMsg.ExecMess.mn_Node.ln_Pri = 0;
  224.     XiMsg.ExecMess.mn_Length = sizeof(struct XiMessage);
  225.     XiMsg.ExecMess.mn_ReplyPort = XiReplyPort;
  226.     XiMsg.Label = 0x12345678;                           /* Erkennungsmarke für XiPaint, sehr wichtig !!!! */
  227. //-
  228.  
  229.   //
  230.   // Action!
  231.   //
  232.  
  233.   box = open_gauge("Filter");
  234.   strcpy(ProjName,io.proname);
  235.   if ((lock_project(&w,&h,&mem)) == FALSE)
  236.   {
  237.       set_gauge(box,100);
  238.       goto Ende;
  239.   }
  240.  
  241.   if (io.minipic == 1)   // Speicher holen, minipic generieren, berechnen, anzeigen
  242.   {
  243.     bru = calloc(REQ_PIC_W * REQ_PIC_H ,sizeof(union color));
  244.     if (bru)
  245.     {
  246.       make_minipic((ULONG *)mem, w,h,(ULONG *)bru,REQ_PIC_W, REQ_PIC_H);
  247.       if (strcmp(io.ext.format, info.format ) == 0)
  248.         filter_picture_smo(REQ_PIC_W, REQ_PIC_H, bru);
  249.       else if (strcmp(io.ext.format, info1.format ) == 0)
  250.         filter_picture_sme(REQ_PIC_W, REQ_PIC_H, bru);
  251.  
  252.       // Send result and wait
  253.       send_mpic(REQ_PIC_W, REQ_PIC_H, bru, str_id);
  254.       free(bru);
  255.  
  256.     }
  257.     else
  258.     {
  259.       // Errormeldung ... no memory
  260.     }
  261.   }
  262.   else
  263.   {
  264.     if (strcmp(io.ext.format, info.format ) == 0)
  265.       filter_picture_smo(w,h,(union color *)mem);
  266.     else if (strcmp(io.ext.format, info1.format ) == 0)
  267.       filter_picture_sme(w,h,(union color *)mem);
  268.   }
  269.     set_gauge(box,100);
  270.     update_project();   // Show the work
  271.     unlock_project();   // XiPaint can work
  272.  
  273.   // End-Work
  274.  Ende:
  275.     DeletePort(XiReplyPort);
  276. }
  277.  
  278. // Waits till WaitMsg comes from Reply-port
  279. //+ "void WaitReply(struct MsgPort *ReplyPort, struct Message *WaitMsg)"
  280.  
  281. void WaitReply(struct MsgPort *ReplyPort, struct Message *WaitMsg)
  282. {
  283.   struct Message *OkMsg;
  284.   BOOL Loop=TRUE;
  285.  
  286.   while(Loop)
  287.   {
  288.     WaitPort(ReplyPort);
  289.     while( OkMsg = GetMsg(ReplyPort) )
  290.     {
  291.       if ( OkMsg == WaitMsg )
  292.         Loop = FALSE;
  293.     }
  294.   }
  295. }
  296. //-
  297.  
  298. //
  299. // Functions to handle everything easier with XiPaint MsgPort
  300. //
  301.  
  302. //+ "BOOL open_xi_project(UWORD *w, UWORD *h, ULONG **mem)"
  303.  
  304. BOOL open_xi_project(UWORD *w, UWORD *h, ULONG **mem, char *name)
  305. {
  306.   sprintf(ProjName, "____%s",name);                      /* Puffer initialisieren */
  307.  
  308.   XiMsg.Command = XI_NEW_PROJECT;                             /* Kommando ausfüllen */
  309.   XiMsg.ProjectName = ProjName;                               /* Name des Projekts */
  310.   XiMsg.Width = (short)*w;                                          /* Größe des Projekts */
  311.   XiMsg.Height = (short)*h;
  312.  
  313.   PutMsg(XiUserPort, (struct Message *)&XiMsg);               /* Message absenden */
  314.   WaitReply(XiReplyPort, (struct Message *)&XiMsg);           /* Warten auf Reply, siehe Fkt. unten */
  315.  
  316.   if ( XiMsg.Success == TRUE )                        /* Aktion war erfolgreich */
  317.   {
  318.     *mem = (ULONG *)XiMsg.Memory;                               /* Auswerten der Rückgabewerte */
  319.     *w = (UWORD)XiMsg.Width;                    /* Wichtig: Größe kann sich geändert haben (größer geworden) */
  320.     *h = (UWORD)XiMsg.Height;                  /* daher ist ein Übernehem der neuen Größe unbedingt erforderlich !! */
  321.   }
  322.   else
  323.   {
  324.     printf("Couldn't open Projekt '%s'\n", ProjName);
  325.     return(FALSE);
  326.   }
  327. }
  328. //-
  329. //+ "void send_error(char *string)"
  330.  
  331. void send_error(char *string)
  332. {
  333.   XiMsg.Command = XI_PUT_ERROR;                             /* Kommando ausfüllen */
  334.   XiMsg.ProjectName = ProjName;                               /* Name des Projekts */
  335.   XiMsg.Memory = string;
  336.   PutMsg(XiUserPort, (struct Message *)&XiMsg);               /* Message absenden */
  337.   WaitReply(XiReplyPort, (struct Message *)&XiMsg);           /* Warten auf Reply, siehe Fkt. unten */
  338. }
  339. //-
  340. //+ "void *open_gauge(char *title)"
  341.  
  342. void *open_gauge(char *title)
  343. {
  344.   XiMsg.Command = XI_OPEN_GAUGE;                             /* Kommando ausfüllen */
  345.   XiMsg.Memory = title;
  346.   PutMsg(XiUserPort, (struct Message *)&XiMsg);               /* Message absenden */
  347.   WaitReply(XiReplyPort, (struct Message *)&XiMsg);           /* Warten auf Reply, siehe Fkt. unten */
  348.   return(XiMsg.Memory);
  349. }
  350. //-
  351. //+ "void set_gauge(void *box, WORD prozent)"
  352.  
  353. void set_gauge(void *box, WORD prozent)
  354. {
  355.   XiMsg.Command = XI_MOVE_GAUGE;                             /* Kommando ausfüllen */
  356.   XiMsg.Memory = box;
  357.   XiMsg.Width = prozent;
  358.   PutMsg(XiUserPort, (struct Message *)&XiMsg);               /* Message absenden */
  359.   WaitReply(XiReplyPort, (struct Message *)&XiMsg);           /* Warten auf Reply, siehe Fkt. unten */
  360. }
  361. //-
  362. //+ "void update_project(void)"
  363.  
  364. void update_project(void)
  365. {
  366.   XiMsg.Command = XI_UPDATE_PROJECT;                      /* Kommando ausfüllen */
  367.   XiMsg.ProjectName = ProjName;                           /* ProjName-Variable durch Open-Call auf Namen mit Kennung geändert  !!!! */
  368.   PutMsg(XiUserPort, (struct Message *)&XiMsg);           /* Message absenden */
  369.   WaitReply(XiReplyPort, (struct Message *)&XiMsg);       /* Warten auf Reply, siehe Fkt. unten, Erfolgscheck nicht notwendig */
  370. }
  371. //-
  372. //+ "BOOL unlock_project(void)"
  373.  
  374. BOOL unlock_project(void)
  375. {
  376.   XiMsg.Command = XI_UNLOCK_PROJECT;                          /* Kommando ausfüllen */
  377.   XiMsg.ProjectName = ProjName;                               /* Name des Projekts */
  378.  
  379.   PutMsg(XiUserPort, (struct Message *)&XiMsg);               /* Message absenden */
  380.   WaitReply(XiReplyPort, (struct Message *)&XiMsg);           /* Warten auf Reply, siehe Fkt. unten */
  381.  
  382.   if ( XiMsg.Success == FALSE )                        /* Aktion war erfolgreich (sollte immer sein...) */
  383.   {
  384.     char buf[80];
  385.     sprintf(buf,"Couldn't unlock '%s'!\n", ProjName);
  386.     send_error(buf);
  387.     return(FALSE);
  388.   }
  389.   return(TRUE);
  390. }
  391. //-
  392. //+ "BOOL lock_project(UWORD *w, UWORD *h, ULONG **mem)"
  393.  
  394. BOOL lock_project(UWORD *w, UWORD *h, ULONG **mem)
  395. {
  396.   XiMsg.Command = XI_LOCK_PROJECT;                            /* Kommando ausfüllen */
  397.   XiMsg.ProjectName = ProjName;                               /* Name des Projekts */
  398.  
  399.   PutMsg(XiUserPort, (struct Message *)&XiMsg);               /* Message absenden */
  400.   WaitReply(XiReplyPort, (struct Message *)&XiMsg);           /* Warten auf Reply, siehe Fkt. unten */
  401.  
  402.   if ( XiMsg.Success == TRUE )                        /* Aktion war erfolgreich */
  403.   {
  404.     *mem = (ULONG *)XiMsg.Memory;                               /* Auswerten der Rückgabewerte */
  405.     *w = XiMsg.Width;
  406.     *h = XiMsg.Height;
  407.   }
  408.   else
  409.   {
  410.     char buf[80];
  411.     sprintf(buf,"Couldn't lock '%s'!\n", ProjName);
  412.     send_error(buf);
  413.     return(FALSE);
  414.   }
  415.   return(TRUE);
  416. }
  417. //-
  418. //+ "BOOL get_brush_mem(UWORD w, UWORD h, ULONG **mem)"
  419.  
  420. BOOL get_brush_mem(UWORD w, UWORD h, ULONG **mem)
  421. {
  422.   XiMsg.Command = XI_NEW_BRUSH;                             /* Kommando ausfüllen */
  423.   XiMsg.Width  = w;                                          /* Größe des Projekts */
  424.   XiMsg.Height = h;
  425.  
  426.   PutMsg(XiUserPort, (struct Message *)&XiMsg);               /* Message absenden */
  427.   WaitReply(XiReplyPort, (struct Message *)&XiMsg);           /* Warten auf Reply, siehe Fkt. unten */
  428.  
  429.   if ( XiMsg.Success == TRUE )                        /* Aktion war erfolgreich */
  430.   {
  431.     *mem = (ULONG *)XiMsg.Memory;
  432.   }
  433.   else
  434.   {
  435.     send_error("No memory for brush\nfrom XiPaint!\n");
  436.     return(FALSE);
  437.   }
  438.   return(TRUE);
  439. }
  440. //-
  441. void send_mpic(WORD w, WORD h, union color *mem, char *id)
  442. {
  443.   XiMsg.Command = XI_MOVE_PIC;                             /* Kommando ausfüllen */
  444.   XiMsg.ProjectName = id;                               /* Name des Projekts */
  445.   XiMsg.Memory = (char *)mem;
  446.   XiMsg.Width = w;
  447.   XiMsg.Height = h;
  448.  
  449.   PutMsg(XiUserPort, (struct Message *)&XiMsg);               /* Message absenden */
  450.   WaitReply(XiReplyPort, (struct Message *)&XiMsg);           /* Warten auf Reply, siehe Fkt. unten */
  451. }
  452.  
  453.  
  454. //+ "void filter_picture_smo(WORD w,WORD h,union color *mem)"
  455.  
  456. void filter_picture_smo(WORD w,WORD h,union color *mem)
  457. {
  458.  WORD i,j;
  459. #if 0
  460.  union color help;
  461.  
  462.  for (j=0;j<h;j++)
  463.  {
  464.    set_gauge(box,j*99/h);
  465.    for (i=0;i<w;i++)
  466.    {
  467.      help.c24 = mem[j*w+i].c24;
  468.      help.c8[RED] = help.c8[BLU] + help.c8[GRN];
  469.      mem[j*w+i].c24 = help.c24;
  470.    }
  471.  }
  472.  #endif
  473.  struct brush b;
  474.  
  475.  b.memory = mem;
  476.  b.width = w;
  477.  b.height = h;
  478.  
  479.  for (j=0;j<h;j++)
  480.  {
  481.    set_gauge(box,j*99/h);
  482.    for (i=0;i<w;i++)
  483.    {
  484.      smooth_point(&b,i,j);
  485.    }
  486.  }
  487. }
  488. //-
  489. //+ "void filter_picture_sme(WORD w,WORD h,union color *mem)"
  490.  
  491. void filter_picture_sme(WORD w,WORD h,union color *mem)
  492. {
  493.  WORD i,j;
  494.  struct brush b;
  495.  
  496.  b.memory = mem;
  497.  b.width = w;
  498.  b.height = h;
  499.  w --;
  500.  h--;
  501.  for (j=0;j<h;j++)
  502.  {
  503.    set_gauge(box,j*99/h);
  504.    for (i=0;i<w;i++)
  505.    {
  506.      smear_point(&b,i,j);
  507.    }
  508.  }
  509. }
  510. //-
  511.  
  512.  
  513. //+ "BOOL make_minipic (ULONG *src, WORD swidth, WORD sheight,"
  514. BOOL make_minipic (ULONG *src, WORD swidth, WORD sheight,
  515.                    ULONG *dest, WORD dwidth, WORD dheight)
  516. {
  517.   WORD k,offx = -1, offy = -1;
  518.   UWORD sizeX, sizeY;
  519.   double facd,facs;
  520.  
  521.   if (dest == NULL)
  522.     return (FALSE);
  523.   if (dwidth == 0)
  524.     return (FALSE);
  525.   if (dheight == 0)
  526.     return (FALSE);
  527.  
  528.   memset (dest, (size_t) (dwidth * dheight * sizeof (ULONG)), 0);     /* Schwarzer Rand */
  529.  
  530.   if ( (src == NULL) || (swidth == 0) || (sheight == 0) )
  531.     return (TRUE);
  532.  
  533.   /* printf("sw:%d sh:%d, dw:%d, dh:%d\n",swidth, sheight, dwidth, dheight); */
  534.  
  535.   if (swidth <= dwidth)
  536.     offx = (dwidth - swidth) / 2;                /* Offset in Breite Bestimmen */
  537.  
  538.   if (sheight <= dheight)                         /* Offset in Höhe */
  539.     offy = (dheight - sheight) / 2;
  540.  
  541.   if ( (offx > -1) && (offy > -1) )           /* Paßt komplett ins Bild */
  542.     {
  543.     for (k = 0; k < sheight; k++)
  544.       {
  545.       ULONG *B1Buffer, *End;
  546.  
  547.       for (B1Buffer = dest + ( (k+offy) * dwidth + offx), End = B1Buffer + swidth;
  548.            B1Buffer < End; B1Buffer++, src++)
  549.         {
  550.           *B1Buffer = *src;
  551.         }
  552.       }
  553.       return(TRUE);
  554.     }
  555.  
  556.   facs = (double)swidth / (double)sheight;
  557.   facd = (double)dwidth / (double)dheight;
  558.  
  559.   if (facs  > facd)
  560.   {
  561.     facd = (double)swidth / (double)dwidth;
  562.     sizeY = (UWORD)((double)sheight / facd);
  563.     offy = (dheight - sizeY) / 2;
  564.  
  565.     sizeX = dwidth * 1000 / swidth;
  566.     sizeY = sizeY * 1000 / sheight;
  567.  
  568.     dheight= dheight - 2*offy - 1;
  569.  
  570.     for (k = 0; k < dheight; k++)
  571.     {
  572.       ULONG *B1Buffer, *B2Buffer, *End;
  573.       UWORD index;
  574.  
  575.       for (B1Buffer = dest + ((k+offy) * dwidth),
  576.          B2Buffer = src + (((k * 1000) / sizeY) * swidth),
  577.          End = B1Buffer + dwidth,
  578.          index = 0;
  579.          B1Buffer < End; B1Buffer++, index++)
  580.       {
  581.         *B1Buffer = *(B2Buffer + index * 1000 / sizeX);
  582.       }
  583.     }
  584.   }
  585.   else
  586.   {
  587.     WORD neww;
  588.  
  589.     facd = (double)sheight / (double)dheight;
  590.     sizeX = (UWORD)((double)swidth / facd);
  591.     offx = (dwidth - sizeX) / 2;
  592.  
  593.     sizeX = sizeX * 1000 / swidth;
  594.     sizeY = dheight * 1000 / sheight;
  595.  
  596.     neww = dwidth - 2 * offx;
  597.  
  598.     for (k = 0; k < dheight; k++)
  599.     {
  600.       ULONG *B1Buffer, *B2Buffer, *End;
  601.       UWORD index;
  602.  
  603.       for (B1Buffer = dest + (k * dwidth)+offx,
  604.          B2Buffer = src + (((k * 1000) / sizeY) * swidth),
  605.          End = B1Buffer + neww,
  606.          index = 0;
  607.          B1Buffer < End; B1Buffer++, index++)
  608.       {
  609.         *B1Buffer = *(B2Buffer + index * 1000 / sizeX);
  610.       }
  611.     }
  612.   }
  613.  
  614.   return (TRUE);
  615. }
  616. //-
  617.  
  618.  
  619. //+ "void smooth_point (struct brush *omega, SHORT x, SHORT y)"
  620.  
  621. void smooth_point (struct brush *omega, SHORT x, SHORT y)
  622. {
  623.   WORD r = 0, g = 0, b = 0;
  624.   WORD ox, oy;
  625.   static union color rpix;
  626.   LONG i;
  627.  
  628.   if (!((x < 1) || (x > (omega->width - 2)) || (y < 1) || (y > (omega->height - 2))))
  629.   {
  630.     ox = x;
  631.     oy = y;
  632.     x--;
  633.     y--;                                                                       /* Links oben beginnen */
  634.     for (i = x; i < x + 3; i++)
  635.     {
  636.       rpix.c24 = (omega->memory + (y * omega->width + i))->c24;                /* Pixel lesen */
  637.       r += rpix.c8[RED];
  638.       g += rpix.c8[GRN];
  639.       b += rpix.c8[BLU];
  640.     }
  641.     y++;
  642.     for (i = x; i < x + 3; i++)
  643.     {
  644.       rpix.c24 = (omega->memory + (y * omega->width + i))->c24;                /* Pixel lesen */
  645.       r += rpix.c8[RED];
  646.       g += rpix.c8[GRN];
  647.       b += rpix.c8[BLU];
  648.     }
  649.     y++;
  650.     for (i = x; i < x + 3; i++)
  651.     {
  652.       rpix.c24 = (omega->memory + (y * omega->width + i))->c24;                /* Pixel lesen */
  653.       r += rpix.c8[RED];
  654.       g += rpix.c8[GRN];
  655.       b += rpix.c8[BLU];
  656.     }
  657.  
  658.     rpix.c8[RED] = r / 9;
  659.     rpix.c8[GRN] = g / 9;
  660.     rpix.c8[BLU] = b / 9;
  661.  
  662.     (omega->memory + (oy * omega->width + ox))->c8[RED] = rpix.c8[RED];
  663.     (omega->memory + (oy * omega->width + ox))->c8[GRN] = rpix.c8[GRN];
  664.     (omega->memory + (oy * omega->width + ox))->c8[BLU] = rpix.c8[BLU];
  665.   }
  666. }
  667. //-
  668.  
  669. /*********************************************************************************
  670.    smear_point liest Mittelpunkt und mischt mit Umgebung ( 50% )
  671.    Umständlich, aber schnell. Clipping ist nicht trivial, Doppelschleife geht nicht
  672.    wegen Mittelpunkt!
  673.  
  674.    Achtung! Bei eingeschalteter Maske wird trotzdem diese verändert!
  675. ********************************************************************************/
  676. //+ "void smear_point (struct brush *omega, SHORT x, SHORT y)                       /* auf x, y geclipped! */"
  677.  
  678. void smear_point (struct brush *omega, SHORT x, SHORT y)                       /* auf x, y geclipped! */
  679. {
  680.   static union color rpix, wpix;
  681.  
  682.   rpix.c24 = (omega->memory + (y * omega->width + x))->c24;                    /* Pixel lesen */
  683.   rpix.c8[RED] /= 2;
  684.   rpix.c8[GRN] /= 2;
  685.   rpix.c8[BLU] /= 2;
  686.  
  687.   if (x == 0)
  688.   {
  689.     if (y == 0)
  690.     {
  691.       x++;
  692.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  693.       wpix.c8[RED] /= 2;
  694.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  695.       wpix.c8[GRN] /= 2;
  696.       wpix.c8[GRN] += rpix.c8[GRN];
  697.       wpix.c8[BLU] /= 2;
  698.       wpix.c8[BLU] += rpix.c8[BLU];
  699.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;                /* Schreiben */
  700.       y++;
  701.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  702.       wpix.c8[RED] /= 2;
  703.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  704.       wpix.c8[GRN] /= 2;
  705.       wpix.c8[GRN] += rpix.c8[GRN];
  706.       wpix.c8[BLU] /= 2;
  707.       wpix.c8[BLU] += rpix.c8[BLU];
  708.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  709.       x--;
  710.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  711.       wpix.c8[RED] /= 2;
  712.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  713.       wpix.c8[GRN] /= 2;
  714.       wpix.c8[GRN] += rpix.c8[GRN];
  715.       wpix.c8[BLU] /= 2;
  716.       wpix.c8[BLU] += rpix.c8[BLU];
  717.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  718.     }
  719.     else if (y == (omega->height - 1))
  720.     {
  721.       y--;
  722.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  723.       wpix.c8[RED] /= 2;
  724.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  725.       wpix.c8[GRN] /= 2;
  726.       wpix.c8[GRN] += rpix.c8[GRN];
  727.       wpix.c8[BLU] /= 2;
  728.       wpix.c8[BLU] += rpix.c8[BLU];
  729.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  730.       x++;
  731.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  732.       wpix.c8[RED] /= 2;
  733.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  734.       wpix.c8[GRN] /= 2;
  735.       wpix.c8[GRN] += rpix.c8[GRN];
  736.       wpix.c8[BLU] /= 2;
  737.       wpix.c8[BLU] += rpix.c8[BLU];
  738.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  739.       y++;
  740.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  741.       wpix.c8[RED] /= 2;
  742.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  743.       wpix.c8[GRN] /= 2;
  744.       wpix.c8[GRN] += rpix.c8[GRN];
  745.       wpix.c8[BLU] /= 2;
  746.       wpix.c8[BLU] += rpix.c8[BLU];
  747.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  748.     }
  749.     else
  750.     {
  751.       y--;
  752.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  753.       wpix.c8[RED] /= 2;
  754.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  755.       wpix.c8[GRN] /= 2;
  756.       wpix.c8[GRN] += rpix.c8[GRN];
  757.       wpix.c8[BLU] /= 2;
  758.       wpix.c8[BLU] += rpix.c8[BLU];
  759.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  760.       x++;
  761.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  762.       wpix.c8[RED] /= 2;
  763.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  764.       wpix.c8[GRN] /= 2;
  765.       wpix.c8[GRN] += rpix.c8[GRN];
  766.       wpix.c8[BLU] /= 2;
  767.       wpix.c8[BLU] += rpix.c8[BLU];
  768.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  769.       y++;
  770.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  771.       wpix.c8[RED] /= 2;
  772.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  773.       wpix.c8[GRN] /= 2;
  774.       wpix.c8[GRN] += rpix.c8[GRN];
  775.       wpix.c8[BLU] /= 2;
  776.       wpix.c8[BLU] += rpix.c8[BLU];
  777.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  778.       y++;
  779.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  780.       wpix.c8[RED] /= 2;
  781.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  782.       wpix.c8[GRN] /= 2;
  783.       wpix.c8[GRN] += rpix.c8[GRN];
  784.       wpix.c8[BLU] /= 2;
  785.       wpix.c8[BLU] += rpix.c8[BLU];
  786.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  787.       x--;
  788.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  789.       wpix.c8[RED] /= 2;
  790.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  791.       wpix.c8[GRN] /= 2;
  792.       wpix.c8[GRN] += rpix.c8[GRN];
  793.       wpix.c8[BLU] /= 2;
  794.       wpix.c8[BLU] += rpix.c8[BLU];
  795.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  796.     }
  797.   }
  798.   else if (x == (omega->width + 1))
  799.   {
  800.     if (y == 0)
  801.     {
  802.       x--;
  803.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  804.       wpix.c8[RED] /= 2;
  805.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  806.       wpix.c8[GRN] /= 2;
  807.       wpix.c8[GRN] += rpix.c8[GRN];
  808.       wpix.c8[BLU] /= 2;
  809.       wpix.c8[BLU] += rpix.c8[BLU];
  810.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  811.       y++;
  812.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  813.       wpix.c8[RED] /= 2;
  814.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  815.       wpix.c8[GRN] /= 2;
  816.       wpix.c8[GRN] += rpix.c8[GRN];
  817.       wpix.c8[BLU] /= 2;
  818.       wpix.c8[BLU] += rpix.c8[BLU];
  819.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  820.       x++;
  821.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  822.       wpix.c8[RED] /= 2;
  823.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  824.       wpix.c8[GRN] /= 2;
  825.       wpix.c8[GRN] += rpix.c8[GRN];
  826.       wpix.c8[BLU] /= 2;
  827.       wpix.c8[BLU] += rpix.c8[BLU];
  828.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  829.     }
  830.     else if (y == (omega->height - 1))
  831.     {
  832.       y--;
  833.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  834.       wpix.c8[RED] /= 2;
  835.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  836.       wpix.c8[GRN] /= 2;
  837.       wpix.c8[GRN] += rpix.c8[GRN];
  838.       wpix.c8[BLU] /= 2;
  839.       wpix.c8[BLU] += rpix.c8[BLU];
  840.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  841.       x--;
  842.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  843.       wpix.c8[RED] /= 2;
  844.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  845.       wpix.c8[GRN] /= 2;
  846.       wpix.c8[GRN] += rpix.c8[GRN];
  847.       wpix.c8[BLU] /= 2;
  848.       wpix.c8[BLU] += rpix.c8[BLU];
  849.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  850.       y++;
  851.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  852.       wpix.c8[RED] /= 2;
  853.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  854.       wpix.c8[GRN] /= 2;
  855.       wpix.c8[GRN] += rpix.c8[GRN];
  856.       wpix.c8[BLU] /= 2;
  857.       wpix.c8[BLU] += rpix.c8[BLU];
  858.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  859.     }
  860.     else
  861.     {
  862.       y--;
  863.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  864.       wpix.c8[RED] /= 2;
  865.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  866.       wpix.c8[GRN] /= 2;
  867.       wpix.c8[GRN] += rpix.c8[GRN];
  868.       wpix.c8[BLU] /= 2;
  869.       wpix.c8[BLU] += rpix.c8[BLU];
  870.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  871.       x--;
  872.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  873.       wpix.c8[RED] /= 2;
  874.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  875.       wpix.c8[GRN] /= 2;
  876.       wpix.c8[GRN] += rpix.c8[GRN];
  877.       wpix.c8[BLU] /= 2;
  878.       wpix.c8[BLU] += rpix.c8[BLU];
  879.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  880.       y++;
  881.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  882.       wpix.c8[RED] /= 2;
  883.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  884.       wpix.c8[GRN] /= 2;
  885.       wpix.c8[GRN] += rpix.c8[GRN];
  886.       wpix.c8[BLU] /= 2;
  887.       wpix.c8[BLU] += rpix.c8[BLU];
  888.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  889.       y++;
  890.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  891.       wpix.c8[RED] /= 2;
  892.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  893.       wpix.c8[GRN] /= 2;
  894.       wpix.c8[GRN] += rpix.c8[GRN];
  895.       wpix.c8[BLU] /= 2;
  896.       wpix.c8[BLU] += rpix.c8[BLU];
  897.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  898.       x++;
  899.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  900.       wpix.c8[RED] /= 2;
  901.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  902.       wpix.c8[GRN] /= 2;
  903.       wpix.c8[GRN] += rpix.c8[GRN];
  904.       wpix.c8[BLU] /= 2;
  905.       wpix.c8[BLU] += rpix.c8[BLU];
  906.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  907.     }
  908.   }
  909.   else
  910.   {
  911.     if (y == 0)
  912.     {
  913.       x--;
  914.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  915.       wpix.c8[RED] /= 2;
  916.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  917.       wpix.c8[GRN] /= 2;
  918.       wpix.c8[GRN] += rpix.c8[GRN];
  919.       wpix.c8[BLU] /= 2;
  920.       wpix.c8[BLU] += rpix.c8[BLU];
  921.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  922.       y++;
  923.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  924.       wpix.c8[RED] /= 2;
  925.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  926.       wpix.c8[GRN] /= 2;
  927.       wpix.c8[GRN] += rpix.c8[GRN];
  928.       wpix.c8[BLU] /= 2;
  929.       wpix.c8[BLU] += rpix.c8[BLU];
  930.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  931.       x++;
  932.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  933.       wpix.c8[RED] /= 2;
  934.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  935.       wpix.c8[GRN] /= 2;
  936.       wpix.c8[GRN] += rpix.c8[GRN];
  937.       wpix.c8[BLU] /= 2;
  938.       wpix.c8[BLU] += rpix.c8[BLU];
  939.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  940.       x++;
  941.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  942.       wpix.c8[RED] /= 2;
  943.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  944.       wpix.c8[GRN] /= 2;
  945.       wpix.c8[GRN] += rpix.c8[GRN];
  946.       wpix.c8[BLU] /= 2;
  947.       wpix.c8[BLU] += rpix.c8[BLU];
  948.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  949.       y--;
  950.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  951.       wpix.c8[RED] /= 2;
  952.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  953.       wpix.c8[GRN] /= 2;
  954.       wpix.c8[GRN] += rpix.c8[GRN];
  955.       wpix.c8[BLU] /= 2;
  956.       wpix.c8[BLU] += rpix.c8[BLU];
  957.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  958.     }
  959.     else if (y == (omega->height - 1))
  960.     {
  961.       x--;
  962.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  963.       wpix.c8[RED] /= 2;
  964.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  965.       wpix.c8[GRN] /= 2;
  966.       wpix.c8[GRN] += rpix.c8[GRN];
  967.       wpix.c8[BLU] /= 2;
  968.       wpix.c8[BLU] += rpix.c8[BLU];
  969.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  970.       y--;
  971.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  972.       wpix.c8[RED] /= 2;
  973.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  974.       wpix.c8[GRN] /= 2;
  975.       wpix.c8[GRN] += rpix.c8[GRN];
  976.       wpix.c8[BLU] /= 2;
  977.       wpix.c8[BLU] += rpix.c8[BLU];
  978.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  979.       x++;
  980.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  981.       wpix.c8[RED] /= 2;
  982.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  983.       wpix.c8[GRN] /= 2;
  984.       wpix.c8[GRN] += rpix.c8[GRN];
  985.       wpix.c8[BLU] /= 2;
  986.       wpix.c8[BLU] += rpix.c8[BLU];
  987.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  988.       x++;
  989.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  990.       wpix.c8[RED] /= 2;
  991.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  992.       wpix.c8[GRN] /= 2;
  993.       wpix.c8[GRN] += rpix.c8[GRN];
  994.       wpix.c8[BLU] /= 2;
  995.       wpix.c8[BLU] += rpix.c8[BLU];
  996.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  997.       y++;
  998.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  999.       wpix.c8[RED] /= 2;
  1000.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  1001.       wpix.c8[GRN] /= 2;
  1002.       wpix.c8[GRN] += rpix.c8[GRN];
  1003.       wpix.c8[BLU] /= 2;
  1004.       wpix.c8[BLU] += rpix.c8[BLU];
  1005.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  1006.     }
  1007.     else
  1008.     {
  1009.       x--;
  1010.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  1011.       wpix.c8[RED] /= 2;
  1012.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  1013.       wpix.c8[GRN] /= 2;
  1014.       wpix.c8[GRN] += rpix.c8[GRN];
  1015.       wpix.c8[BLU] /= 2;
  1016.       wpix.c8[BLU] += rpix.c8[BLU];
  1017.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  1018.       y--;
  1019.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  1020.       wpix.c8[RED] /= 2;
  1021.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  1022.       wpix.c8[GRN] /= 2;
  1023.       wpix.c8[GRN] += rpix.c8[GRN];
  1024.       wpix.c8[BLU] /= 2;
  1025.       wpix.c8[BLU] += rpix.c8[BLU];
  1026.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  1027.       x++;
  1028.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  1029.       wpix.c8[RED] /= 2;
  1030.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  1031.       wpix.c8[GRN] /= 2;
  1032.       wpix.c8[GRN] += rpix.c8[GRN];
  1033.       wpix.c8[BLU] /= 2;
  1034.       wpix.c8[BLU] += rpix.c8[BLU];
  1035.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  1036.       x++;
  1037.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  1038.       wpix.c8[RED] /= 2;
  1039.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  1040.       wpix.c8[GRN] /= 2;
  1041.       wpix.c8[GRN] += rpix.c8[GRN];
  1042.       wpix.c8[BLU] /= 2;
  1043.       wpix.c8[BLU] += rpix.c8[BLU];
  1044.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  1045.       y++;
  1046.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  1047.       wpix.c8[RED] /= 2;
  1048.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  1049.       wpix.c8[GRN] /= 2;
  1050.       wpix.c8[GRN] += rpix.c8[GRN];
  1051.       wpix.c8[BLU] /= 2;
  1052.       wpix.c8[BLU] += rpix.c8[BLU];
  1053.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  1054.       y++;
  1055.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  1056.       wpix.c8[RED] /= 2;
  1057.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  1058.       wpix.c8[GRN] /= 2;
  1059.       wpix.c8[GRN] += rpix.c8[GRN];
  1060.       wpix.c8[BLU] /= 2;
  1061.       wpix.c8[BLU] += rpix.c8[BLU];
  1062.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  1063.       x--;
  1064.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  1065.       wpix.c8[RED] /= 2;
  1066.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  1067.       wpix.c8[GRN] /= 2;
  1068.       wpix.c8[GRN] += rpix.c8[GRN];
  1069.       wpix.c8[BLU] /= 2;
  1070.       wpix.c8[BLU] += rpix.c8[BLU];
  1071.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  1072.       x--;
  1073.       wpix.c24 = (omega->memory + (y * omega->width + x))->c24;                /* Pixel lesen */
  1074.       wpix.c8[RED] /= 2;
  1075.       wpix.c8[RED] += rpix.c8[RED];                                            /* Manipulieren */
  1076.       wpix.c8[GRN] /= 2;
  1077.       wpix.c8[GRN] += rpix.c8[GRN];
  1078.       wpix.c8[BLU] /= 2;
  1079.       wpix.c8[BLU] += rpix.c8[BLU];
  1080.       (omega->memory + (y * omega->width + x))->c24 = wpix.c24;
  1081.     }
  1082.   }
  1083. }
  1084. //-
  1085.  
  1086.  
  1087.